#include <iostream>
using namespace std;

//求圆的面积
//封装有2曾含义
//1 属性和方法进行封装
//2 对属性和方法进行访问控制
//3 类的内部和类的外部 
        //class整个{}都是类的内部 其他是这个类的外部
//类的访问控制关键字
        //public: 修饰的成员变量和函数,可以在类的内部和类的外部访问
        //private: 修饰的成员变量和函数,只能在类的内部使用 不能在类的外部访问
        //protected: 修饰的成员变量和函数,只能在类的内部使用 不能在类的外部访问,  但是用在继承里面可以在子类使用
class MyCircle{
public:
        double m_r;
        double m_s;
        
public:
        double getR(){
                return m_r;
        }
        void setR(double r){
                m_r = r;
        }
        double getS(){
                m_s = 3.1415926*getR()*getR();
                return m_s;
        }
protected:
private:
};

//类的封装的威力
//类封装了成员变量和成员函数 //可以调用成员函数
void printCircle01(MyCircle *pC){
        cout<<"r: "<<pC->getR()<<endl;
        cout<<"s: "<<pC->getS()<<endl;
}
void printCircle02(MyCircle &myc){
        cout<<"s = "<<myc.getS()<<endl;
}
void printCircle(MyCircle myc){

}
int main01(int argc, char const *argv[]){
        MyCircle c1,c2;
        c1.setR(10);
        cout<<"c1 s: "<<c1.getS()<<endl;

        c1.setR(11);
        c2.setR(20);
        printCircle01(&c1);
        printCircle01(&c2);

        //引用
        printCircle02(c2);

        return 0;
}

class MyAdvCircle{
        double m_r2; //没有权限修饰的成员变量 函数 默认是似有属性 private
private:
        double m_r;
        double m_s;
        
public:
        double getR(){
                return m_r;
        }
        void setR(double r){
                m_r = r;
        }
        double getS(){
                m_s = 3.1415926*getR()*getR();
                return m_s;
        }
};

int main02(int argc, char const *argv[]){
        MyAdvCircle c1;
        //c1.m_r = 19; //不能访问
        c1.setR(10);
        return 0;
}

struct AAA{
        int a; //用struct关键字定义的类, 不写 默认属性是public的
public:
protected:
private:
};

int main(int argc, char const *argv[]){
        AAA a1;
        a1.a = 11;
        return 0;
}
